package com.fruit.service.goods.impl;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.fruit.mapper.goods.GoodsMapper;
import com.fruit.pojo.goods.Base;
import com.fruit.pojo.goods.GoodsSpec;
import com.fruit.pojo.goods.InterfaceConfig;
import com.fruit.pojo.goods.RightConfig;
import com.fruit.pojo.goods.GoodsSpecTime;
import com.fruit.pojo.goods.GoodsSpecTimeHarvest;
import com.fruit.service.goods.GoodsManager;
import com.fruit.service.redis.JedisUtil;
import com.fruit.util.CustomUtil;
import com.fruit.util.DateUtil;
import com.fruit.util.ResultInfo;
import com.fruit.util.ResultUtil;

import lombok.extern.slf4j.Slf4j;

/**
 * 
 * @ClassName: GoodsService
 * @author 葛欢欢
 * @version 2017.11.30 16:40
 */
@Slf4j
@Service
public class GoodsService implements GoodsManager {

	@Autowired
	private GoodsMapper goodsMapper;

	@Autowired
	private JedisUtil jedisService;

	@Override
	public void setToken(String key, String value) {
		jedisService.set(key, value);
		jedisService.expire(key, 1800);
	}

	/**
	 * 获取商品详细信息
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param goodsId
	 *            goodsId
	 * @return List<GoodsSpecTime>
	 */
	@Override
	public List<GoodsSpecTime> getGoodsDetail(Integer goodsId) {
		long a = System.currentTimeMillis();
		log.info("【获取商品详细信息service进入时间】" + DateUtil.getTime());
		log.info("【获取商品详细信息service】---【开始】---");
		log.info("【获取商品详细信息service】---【传入的goodsid：】---" + goodsId);
		List<Map<String, String>> unitList = goodsMapper.getUnitNameByUnit();
		Map<String, String> unit = new HashMap<String, String>();
		Map<String, String> unitMap = new HashMap<String, String>();
		if (unitList != null) {
			for (int i = 0; i < unitList.size(); i++) {
				unitMap = unitList.get(i);
				unit.put((String) unitMap.get("unit"), (String) unitMap.get("name"));
			}
		}
		List<GoodsSpecTime> goodsSpecTimeList = goodsMapper.getGoodsDetail(goodsId);
		if (goodsSpecTimeList != null) {
			log.info("【获取商品的个数】 ---" + goodsSpecTimeList.size());
			for (int i = 0; i < goodsSpecTimeList.size(); i++) {
				// endUseTime（...） endTime（年月日）
				GoodsSpecTime goodsSpecTime = goodsSpecTimeList.get(i);
				goodsSpecTime.setUnitDesc(unit.get(goodsSpecTime.getUnit()));
				goodsSpecTime.setHarvestUnitDesc(unit.get(goodsSpecTime.getHarvestUnit()));
				goodsSpecTime.setEndUseTime(DateUtil.yMdhmsToYmd(goodsSpecTime.getEndUseTime()));
				boolean dateB = DateUtil.compareDate(goodsSpecTime.getEndTime(), DateUtil.getTime());
				if (dateB) {
					// true 表示当前系统时间 小于 商品下架时间一样 （商品详情页面的 今日认养时间 为当前系统时间）
					goodsSpecTime.setTodayDate(DateUtil.yMdhmsToYmd(DateUtil.getTime()));
				} else { // false 表示当前系统时间 大于等于 商品下架时间一样 （商品详情页面的 今日认养时间 为下架时间）
					goodsSpecTime.setTodayDate(DateUtil.yMdhmsToYmd(goodsSpecTime.getEndTime()));
				}
				// 此日期必须放到最后进行处理 因为前几行代码用到此未处理的日期
				goodsSpecTime.setEndTime(DateUtil.yMdHmsToCh(goodsSpecTime.getEndTime()));
				String moth = goodsSpecTime.getPickMoth();
				String year = DateUtil.getYear();
				String havaeTime = goodsSpecTime.getExpectHarvestTime();
				
				if(StringUtils.isNotBlank(havaeTime)){
					if(StringUtils.isNotBlank(moth)){
						String mothStr = havaeTime.substring(0,4);
						if(year.equals(mothStr)){
							if(moth.startsWith("0")){
								goodsSpecTime.setPickMoth(moth.substring(1, moth.length()) + "月");
							}else {
								goodsSpecTime.setPickMoth(moth + "月");
							}
						}else{
							if(moth.startsWith("0")){
								goodsSpecTime.setPickMoth(moth.substring(1, moth.length()) + "月 (" + mothStr + ")");
							}else {
								goodsSpecTime.setPickMoth(moth + "月 (" + mothStr + ")");
							}
						}
					}else{
						goodsSpecTime.setPickMoth("已采摘");
					}
				}else{
					goodsSpecTime.setPickMoth("已采摘");
				}
				if(StringUtils.isNotBlank(goodsSpecTime.getMinExpectHarvestTime())){//如果当前时间 小于最小收获时间 那么采摘月份 显示首次采摘
					if(DateUtil.compareDate(goodsSpecTime.getMinExpectHarvestTime(), DateUtil.getDay())){
						goodsSpecTime.setIsFirstPick("00");
					}else{
						goodsSpecTime.setIsFirstPick("01");
					}
				}
			}
		}
		log.info("【获取用户权益信息service返回的结果是个list，在action层 只取一个值】---" + goodsSpecTimeList);
		log.info("【获取用户权益信息详情service】---【结束】---");
		log.info("【获取用户权益信息详情service耗时】" + (System.currentTimeMillis() - a) / 1000f + "秒");
		return goodsSpecTimeList;
	}

	/**
	 * 获取商品规格期次信息
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param params
	 *            params
	 * @return Map<String, Object>
	 */
	@Override
	public Map<String, Object> getGoodsSpecTimeById(Map<String, Object> params) {
		long a = System.currentTimeMillis();
		log.info("【获取商品规格期次信息service进入时间】" + DateUtil.getTime());
		log.info("【获取商品规格期次信息service】---【开始】---");
		log.info("【获取商品规格期次信息service传入的参数params：】 " + params);
		Map<String, Object> resMap = new HashMap<String, Object>();
		try {
			GoodsSpecTime gst = goodsMapper.getGoodsSpecTimeById(params);
			resMap.put("gst", gst);
			resMap.put("result", ResultUtil.initResult(ResultInfo.SUCCESS, "OK", "查询成功!"));
			log.info("【获取商品规格期次信息service返回的结果】-- " + resMap);
			log.info("【获取商品规格期次信息service】---【结束】---");
			log.info("【获取商品规格期次信息service耗时】" + (System.currentTimeMillis() - a) / 1000f + "秒");
			return resMap;
		} catch (Exception e) {
			e.printStackTrace();
			resMap.put("result", ResultUtil.initResult(ResultInfo.ERROR, "exception", "系统异常!"));
			log.info("【获取商品规格期次信息service返回的结果】-- " + resMap);
			log.info("【获取商品规格期次信息service】---【结束】---");
			log.info("【获取商品规格期次信息service耗时】" + (System.currentTimeMillis() - a) / 1000f + "秒");
			return resMap;
		}
	}

	/**
	 * 商品列表
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param pam pam
	 * @return List<GoodsSpec>
	 */
	@Override
	public List<GoodsSpec> getGoodsList(Map<String, Object> pam) {
		long a = System.currentTimeMillis();
		log.info("【商品列表service进入时间】" + DateUtil.getTime());
		log.info("【商品列表service】---【开始】---");
		log.info("【商品列表service传入的参数params：】 " + pam);
		List<GoodsSpec> goodsSpecList = goodsMapper.getGoodsList(pam);
		if (goodsSpecList != null) {
			for (int i = 0; i < goodsSpecList.size(); i++) {
				GoodsSpec goodsSpec = goodsSpecList.get(i);
				if (goodsSpec.getSaleType().equals("00")) {
					goodsSpec.setStockNum(0);
				}
				if (goodsSpec.getStockNum() == 0) { // 如果库存为0 那么状态设置为 售馨状态
					goodsSpec.setSaleType("00");
				}
				String moth = goodsSpec.getPickMoth();
				String year = DateUtil.getYear();
				String havaTime = goodsSpec.getExpectHarvestTime();
				String mothStr = null;
				if(StringUtils.isNotBlank(havaTime)){
					mothStr = havaTime.substring(0,4);
					if(StringUtils.isNotBlank(moth)){
						if(year.equals(mothStr)){
							if(moth.startsWith("0")){
								goodsSpec.setPickMoth(moth.substring(1, moth.length()) + "月");
							}else {
								goodsSpec.setPickMoth(moth + "月");
							}
						}else{
							if(moth.startsWith("0")){
								goodsSpec.setPickMoth(moth.substring(1, moth.length()) + "月 (" + mothStr + ")");
							}else {
								goodsSpec.setPickMoth(moth + "月 (" + mothStr + ")");
							}
						}
					}else{
						goodsSpec.setPickMoth("已采摘");
					}
				}else{
					goodsSpec.setPickMoth("已采摘");
				}
				if(StringUtils.isNotBlank(goodsSpec.getMinExpectHarvestTime())){//如果当前时间 小于最小收获时间 那么采摘月份 显示首次采摘
					if(DateUtil.compareDate(goodsSpec.getMinExpectHarvestTime(), DateUtil.getDay())){
						goodsSpec.setIsFirstPick("00");
					}else{
						goodsSpec.setIsFirstPick("01");
					}
				}
				
			}
		}
		log.info("【商品列表service返回的结果】-- " + goodsSpecList);
		log.info("【商品列表service】---【结束】---");
		log.info("【商品列表service耗时】" + (System.currentTimeMillis() - a) / 1000f + "秒");
		return goodsSpecList;
	}

	/**
	 * 获取基地信息
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param id
	 *            基地id
	 * @return Base
	 */
	@Override
	public Base getBase(Integer id) {
		long systime = System.currentTimeMillis();
		log.info("【获取基地信息service进入时间】" + DateUtil.getTime());
		log.info("【获取基地信息service】---【开始】---");
		log.info("【获取基地信息service传入的参数params：】 " + id);
		// TODO Auto-generated method stub
		Base base = goodsMapper.getBase(id);
		// 当前时间大于6点 小于20点为白天
		boolean a = DateUtil.compareDateHMS(DateUtil.getHMS(), "6:00:00");
		boolean b = DateUtil.compareDateHMS("20:00:00", DateUtil.getHMS());
		if (a && b) { // 如果都是 true的话 说明 当前时间大于6点小于20点 则为白天 否则为黑夜
			base.setTimeType("00");
		} else {
			base.setTimeType("01");
		}
		log.info("【获取基地信息service返回的结果】-- " + base);
		log.info("【获取基地信息service】---【结束】---");
		log.info("【获取基地信息service耗时】" + (System.currentTimeMillis() - systime) / 1000f + "秒");
		return base;
	}

	/**
	 * 根据分类id查询此分类下的所有 子分类
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param classId
	 *            分类id
	 * @return String
	 */
	@Override
	public String getClassIdByPid(String classId) {
		long systime = System.currentTimeMillis();
		log.info("【查询此分类下的所有 子分类service进入时间】" + DateUtil.getTime());
		log.info("【查询此分类下的所有 子分类service】---【开始】---");
		log.info("【查询此分类下的所有 子分类service传入的参数params：】 " + classId);
		// TODO Auto-generated method stub
		List<String> classIdList = goodsMapper.getClassIdByPid(classId);
		String classIds = null;
		if (classIdList != null && classIdList.size() > 0) {
			// 把list的值转换为String类型 用逗号隔开
			classIds = classIdList.get(0);
		}
		log.info("【查询此分类下的所有 子分类service返回的结果】-- " + classIds);
		log.info("【查询此分类下的所有 子分类service】---【结束】---");
		log.info("【查询此分类下的所有 子分类service耗时】" + (System.currentTimeMillis() - systime) / 1000f + "秒");
		return classIds;
	}

	/**
	 * 获取单位名称
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @return List<Map<String, String>>
	 */
	@Override
	public List<Map<String, String>> getUnitNameByUnit() {
		log.info("【获取单位名称service】---【开始】---");
		// TODO Auto-generated method stub
		return goodsMapper.getUnitNameByUnit();
	}

	/**
	 * 预计产量信息
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param id
	 *            id
	 * @return List<GoodsSpecTimeHarvest>
	 */
	@Override
	public List<GoodsSpecTimeHarvest> findGoodsSpecTimeHarvest(Integer id) {
		long systime = System.currentTimeMillis();
		log.info("【预计产量信息service进入时间】" + DateUtil.getTime());
		log.info("【预计产量信息service】---【开始】---");
		log.info("【预计产量信息service传入的参数params：】 " + id);
		// TODO Auto-generated method stub
		List<GoodsSpecTimeHarvest> gsh = goodsMapper.findGoodsSpecTimeHarvest(id);
		if (gsh != null && gsh.size() > 0) {
			for (int i = 0; i < gsh.size(); i++) {
				GoodsSpecTimeHarvest gst = gsh.get(i);
				boolean isState = DateUtil.compareDate(DateUtil.getDay(), gst.getExpectHarvestTime());
				if (isState) { // 如果 isState为true 说明预计收获时间大于当前系统时间 那么就 是未收获
								// 如果是小于那么就说 已经收获啦
					gst.setState("00"); // 已收获
				} else {
					gst.setState("01"); // 未收获
				}
				gst.setExpectHarvestTime(DateUtil.yMdToYmd(gst.getExpectHarvestTime()));
			}
		}
		log.info("【预计产量信息service返回的结果】-- " + gsh);
		log.info("【预计产量信息service】---【结束】---");
		log.info("【预计产量信息service耗时】" + (System.currentTimeMillis() - systime) / 1000f + "秒");
		return gsh;
	}

	/**
	 * 获取按钮配置
	 * 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @param appType
	 *            appType
	 * @return List<InterfaceConfig>
	 */
	@Override
	public List<InterfaceConfig> getInterfaceConfig(String appType) {
		return goodsMapper.getInterfaceConfig(appType);
	}

	/**
	 * 获取首页权益配置 
	 * @author 葛欢欢
	 * @version 2017.11.30 16:40
	 * @return List<RightConfig>
	 */
	@Override
	public List<RightConfig> getRightConfigList(String type) {
		return goodsMapper.getRightConfigList(type);
	}

	@Override
	public List<Long> getGoodsHarvestIdsByNotifyTime(String notifyTime) {
		return goodsMapper.getGoodsHarvestIdsByNotifyTime(notifyTime);
	}

	@Override
	public GoodsSpecTimeHarvest getGoodsHarvestById(int id) {
		return goodsMapper.getGoodsHarvestById(id);
	}

	@Override
	public Map<String, Object> getGoodsHall(String type) {
		Map<String, Object> resMap = new HashMap<String, Object>();
		List<RightConfig> rcL = goodsMapper.getRightConfigList(type);
		if (rcL.isEmpty()) {
			log.info("【获取认养大厅】---【未查询到数据】---");
			resMap.put("result", ResultUtil.initResult(ResultInfo.ERROR, "no", "未查询到数据"));
			return resMap;
		}
		Map<String, Object> params = new HashMap<>();
		List<Map<String, Object>> resList = new ArrayList<Map<String, Object>>();
		for(RightConfig rc:rcL){
			List<String> classList = goodsMapper.getClassIdByPid(rc.getClassId());
			params.put("classId", classList.get(0));
			params.put("start", 0);
			params.put("num", 3);
			params.put("saleType", "01");
			params.put("groomPic", "01");
			List<GoodsSpec> gsList = goodsMapper.getGoodsList(params);
			if(gsList != null && gsList.size() > 0){
				Map<String, Object> resOne = new HashMap<String, Object>();
				resOne.put("rc", rc);
				resOne.put("gsList", gsList);
				resList.add(resOne);
			}
		}
		resMap.put("resList", resList);
		resMap.put("result", ResultUtil.initResult(ResultInfo.SUCCESS, "ok", "查询成功"));
		
		return resMap;
	}

	/**
	 * 根据商品期次id查询 商品id
	* @param id
	* @return long
	 */
	public long getGoodsTimeIdByGoodsTimeSpecId(int id) {
		// TODO Auto-generated method stub
		return goodsMapper.getGoodsTimeIdByGoodsTimeSpecId(id);
	}

	/**
	 * 查询商品总数
	* @author 葛欢欢
	* @version 2017.11.30 16:40 
	* @return
	 */ 
	public long getGoodSumNum() {
		// TODO Auto-generated method stub
		return goodsMapper.getGoodSumNum();
	}

	@Override
	public Base getBaseInfo(Integer id) {
		// TODO Auto-generated method stub
		return goodsMapper.getBase(id);
	}
	


}
